// 这是一个简化的JSON库头文件，用于演示目的
// 实际项目中建议使用完整的nlohmann/json库

#ifndef NLOHMANN_JSON_HPP
#define NLOHMANN_JSON_HPP

#include <string>
#include <map>
#include <vector>
#include <iostream>
#include <sstream>

namespace nlohmann {

class json {
private:
    enum 类型 { 对象, 数组, 字符串, 数字, 布尔值, 空值 };
    类型 数据类型 = 空值;
    
    std::map<std::string, json> 对象数据;
    std::vector<json> 数组数据;
    std::string 字符串数据;
    double 数字数据 = 0.0;
    bool 布尔数据 = false;

public:
    json() = default;
    json(const std::string& 值) : 数据类型(字符串), 字符串数据(值) {}
    json(double 值) : 数据类型(数字), 数字数据(值) {}
    json(bool 值) : 数据类型(布尔值), 布尔数据(值) {}
    json(std::nullptr_t) : 数据类型(空值) {}
    
    static json array() { 
        json j; 
        j.数据类型 = 数组; 
        return j; 
    }
    
    static json object() { 
        json j; 
        j.数据类型 = 对象; 
        return j; 
    }
    
    // 数组操作
    json& operator[](size_t 索引) {
        if (数据类型 != 数组) {
            数据类型 = 数组;
            数组数据 = std::vector<json>();
        }
        if (索引 >= 数组数据.size()) {
            数组数据.resize(索引 + 1);
        }
        return 数组数据[索引];
    }
    
    // 对象操作
    json& operator[](const std::string& 键) {
        if (数据类型 != 对象) {
            数据类型 = 对象;
            对象数据 = std::map<std::string, json>();
        }
        return 对象数据[键];
    }
    
    // 类型检查
    bool is_object() const { return 数据类型 == 对象; }
    bool is_array() const { return 数据类型 == 数组; }
    bool is_string() const { return 数据类型 == 字符串; }
    bool is_number() const { return 数据类型 == 数字; }
    bool is_boolean() const { return 数据类型 == 布尔值; }
    bool is_null() const { return 数据类型 == 空值; }
    
    // 获取值
    std::string get_string() const { return 字符串数据; }
    double get_number() const { return 数字数据; }
    bool get_boolean() const { return 布尔数据; }
    
    template<typename T>
    T value(const std::string& 键, T 默认值) const {
        if (数据类型 == 对象) {
            auto it = 对象数据.find(键);
            if (it != 对象数据.end()) {
                if constexpr (std::is_same_v<T, std::string>) {
                    return it->second.is_string() ? it->second.get_string() : 默认值;
                } else if constexpr (std::is_same_v<T, double>) {
                    return it->second.is_number() ? it->second.get_number() : 默认值;
                } else if constexpr (std::is_same_v<T, int>) {
                    return it->second.is_number() ? static_cast<int>(it->second.get_number()) : 默认值;
                } else if constexpr (std::is_same_v<T, bool>) {
                    return it->second.is_boolean() ? it->second.get_boolean() : 默认值;
                }
            }
        }
        return 默认值;
    }
    
    // 数组操作
    void push_back(const json& 值) {
        if (数据类型